#include "cvagasmodel.h"

CVagasModel::CVagasModel(QObject *parent) :
    QAbstractListModel(parent)
{
    this->setRoleNames(CVagasItem::roleNames());
    this->CarregarVagas();
}

CVagasModel::~CVagasModel()
{
    foreach(CVagasItem *x, _vagas)
        delete x;
    _vagas.clear();
}

int CVagasModel::rowCount(const QModelIndex &parent) const
{
    return _vagas.count();
}

QVariant CVagasModel::data(const QModelIndex &index, int role) const
{
    if (index.isValid())
        return _vagas[index.row()]->dados(role);
    return QVariant();
}

void CVagasModel::vagaQuente(CVagasItem *v)
{
    CVagasItem *vCopy = CVagasItem::Clone(v);
    vCopy->moveToThread(this->thread());
    vCopy->setParent(this);
    if (this->ArmazenarVaga(vCopy))
    {
        QObject::connect(vCopy, SIGNAL(dataChanged()), this, SLOT(handleDataChanged()));
        QObject::connect(this, SIGNAL(resetarVagaContatadaSignal()), vCopy, SLOT(resetarVagaContatada()));
        if (_vagas.count() > 0)
        {
            int k;
            for(k = 0; k < _vagas.count(); k++)
            {
                if (_vagas.at(k)->getCodigo() < vCopy->getCodigo())
                    break;
            }
            this->beginInsertRows(QModelIndex(), k, k);
            _vagas.insert(k, vCopy);
            this->endInsertRows();
        }
        else
        {
            this->beginInsertRows(QModelIndex(), 0, 0);
            _vagas.append(vCopy);
            this->endInsertRows();
        }
        vCopy->setVagaNova(true);
        emit quantidadeVagasChanged();
    }
    v->deleteLater();
}

void CVagasModel::limparModelo()
{    
    emit processandoChanged();
    if (_vagas.count() > 0) {
        this->beginRemoveRows(QModelIndex(), 0, _vagas.count() - 1);
        foreach(CVagasItem *vaga, _vagas)
            delete vaga;
        _vagas.clear();
        this->endRemoveRows();
    }
    emit quantidadeVagasChanged();
}

void CVagasModel::posProcessamento()
{    
    emit processandoChanged();
}

QStringList CVagasModel::ListaEstados()
{
    QStringList estados;
    foreach(CVagasItem *c, _vagas)
        if (!estados.contains(c->getEstado()))
            estados.append(c->getEstado());
    estados.sort();
    return estados;
}

QStringList CVagasModel::ListaCidades()
{
    QStringList cidades;
    foreach(CVagasItem *c, _vagas)
        if (!cidades.contains(c->getCidade()))
            cidades.append(c->getCidade());        
    cidades.sort();
    return cidades;
}

QStringList CVagasModel::ListaEmpresas()
{
    QStringList empresas;
    foreach(CVagasItem *c, _vagas)
        if (!empresas.contains(c->getEmpresa()))
            empresas.append(c->getEmpresa());        
    empresas.sort();
    return empresas;
}

void CVagasModel::Marcar(int codigoVaga)
{
    foreach(CVagasItem *x, _vagas)
        if (x->getCodigo() == codigoVaga)
        {
            x->setMarcado(true);            
        }
}    

void CVagasModel::Desmarcar(int codigoVaga)
{
    foreach(CVagasItem *x, _vagas)
        if (x->getCodigo() == codigoVaga)
        {
            x->setMarcado(false);            
        }
}

CVagasItem *CVagasModel::LocalizarVaga(int codigoVaga)
{
    foreach(CVagasItem *x, _vagas)
        if (x->getCodigo() == codigoVaga)
            return x;
    return NULL;
}

void CVagasModel::handleDataChanged()
{
    CVagasItem *obj = qobject_cast<CVagasItem*>(this->sender());
    if (obj)
    {
        for (int i = 0; i < _vagas.count(); i++)
        {
            if (_vagas[i]->getCodigo() == obj->getCodigo())
            {
                emit dataChanged(index(i), index(i));                
                //controlar as vagas marcadas
                QSqlQuery q(QSqlDatabase::database(CConfiguracao::c_basePrincipal));
                if (obj->getMarcado())
                {
                    q.prepare("insert into vagasMarcadas (vaga, dataMarcacao) "
                              "values (:vaga, :dataMarcacao)");
                    q.bindValue(":vaga", obj->getCodigo());
                    q.bindValue(":dataMarcacao", QDateTime::currentDateTime());

                }
                else
                {
                    q.prepare("delete from vagasMarcadas where vaga = :vaga");
                    q.bindValue(":vaga", obj->getCodigo());
                }
                q.exec();
                break;
            }
        }
    }
}

void CVagasModel::desmarcarTodos()
{    
    foreach(CVagasItem *v, _vagas)
        v->setMarcado(false);
}

void CVagasModel::vagaContatada(CVagasItem *v)
{
    v->AtualizarDadosContato(QDateTime::currentDateTime());
    v->setMarcado(false);
}

void CVagasModel::resetarVagaContatada()
{
    emit resetarVagaContatadaSignal();
}

bool CVagasModel::ArmazenarVaga(CVagasItem *v)
{
    QSqlQuery q(QSqlDatabase::database(CConfiguracao::c_basePrincipal));
    q.prepare("insert into vagas( "
              "vaga, "
              "estado, "
              "cidade, "
              "cargo, "
              "descricao, "
              "empresa, "
              "tituloEmail, "
              "data, "
              "contato)"

              "values( "
              ":vaga, "
              ":estado, "
              ":cidade, "
              ":cargo, "
              ":descricao, "
              ":empresa, "
              ":tituloEmail, "
              ":data, "
              ":contato)");
    q.bindValue(":vaga", v->getCodigo());
    q.bindValue(":estado", v->getEstado());
    q.bindValue(":cidade", v->getCidade());
    q.bindValue(":cargo", v->getCargo());
    q.bindValue(":descricao", v->getDescricao());
    q.bindValue(":empresa", v->getEmpresa());
    q.bindValue(":tituloEmail", v->getSubjectEmail());
    q.bindValue(":data", v->getData());
    q.bindValue(":contato", v->getContato());
    q.exec();
    bool ret = q.lastError().isValid();
    return !ret;
}

void CVagasModel::CarregarVagas()
{
    QSqlQuery q(QSqlDatabase::database(CConfiguracao::c_basePrincipal));
    q.exec("select a.vaga, estado, cidade, cargo, descricao, empresa, tituloEmail, data, contato, b.vaga, b.dataContato, c.vaga "
           "from vagas a "
           "left outer join emailsEnviados b on a.vaga = b.vaga "
           "left outer join vagasMarcadas c on a.vaga = c.vaga "
           "where data >= date('now', '-1 month') "
           " or b.vaga is not null "
           "order by a.vaga desc ");
    while (q.next())
    {
        this->beginInsertRows(QModelIndex(), _vagas.count(), _vagas.count());
        CVagasItem *v = new CVagasItem(this);
        v->setCodigo(q.value(0).toInt());
        v->setEstado(q.value(1).toString());
        v->setCidade(q.value(2).toString());
        v->setCargo(q.value(3).toString());
        v->setDescricao(q.value(4).toString());
        v->setEmpresa(q.value(5).toString());
        v->setSubjectEmail(q.value(6).toString());
        v->setData(q.value(7).toDate());
        v->setContato(q.value(8).toString());
        v->setMarcado(!q.value(11).isNull());
        if (!q.value(9).isNull())
            v->AtualizarDadosContato(q.value(10).toDateTime());
        _vagas.append(v);
        QObject::connect(v, SIGNAL(dataChanged()), this, SLOT(handleDataChanged()));
        QObject::connect(this, SIGNAL(resetarVagaContatadaSignal()), v, SLOT(resetarVagaContatada()));
        this->endInsertRows();
    }
}
